/**
 * Git 工作流主命令
 * 提供 feature 分支的创建、同步、完成等操作
 */
import { program } from 'commander';
import path from 'path';
import { exec, execNodeScript } from '../utils/exec.js';
import { Logger } from '../utils/logger.js';
import { GitUtils } from '../utils/git.js';
import config from '../utils/config.js';

const logger = new Logger('[git:flow]');

/**
 * 通用的分支创建函数
 * @param {string} type - 分支类型 ('feat' 或 'fix')
 * @param {string} name - 分支名称
 */
async function startBranch(type, name) {
  if (!name) {
    logger.error(`请提供 ${type} 分支名称。使用: pnpm git:${type} <branch-name>`);
    process.exit(1);
  }

  if (GitUtils.branchExists(`${type}/${name}`)) {
    logger.error(`分支 ${type}/${name} 已在 本地仓库 存在。请勿重复创建。`);
    process.exit(1);
  }

  if (GitUtils.remoteExists(`${type}/${name}`)) {
    logger.error(`分支 ${type}/${name} 已在 远程仓库 存在。请勿重复创建。`);
    process.exit(1);
  }

  const branchName = `${type}/${name}`;

  logger.spinnerStart(`正在创建 ${type} 分支: <${branchName}>`);

  try {
    // 更新 main
    logger.spinnerUpdate('更新 main 分支...');
    GitUtils.checkout('main');
    GitUtils.pull('origin', 'main');
    await logger.spinnerShamefullySleep();

    // 创建新分支
    logger.spinnerUpdate(`从最新 main 分支，创建 ${type} 分支: <${branchName}>`);
    exec(`git checkout -b ${branchName}`, { silent: true });
    await logger.spinnerShamefullySleep();

    logger.spinnerSucceed(
      `${type.charAt(0).toUpperCase() + type.slice(1)} 本地 分支创建完成: <${branchName}>`
    );
    logger.info(`现在可以开始工作了: <${branchName}>`);
  } catch (error) {
    logger.spinnerFail(`创建 ${type} 分支失败: <${branchName}>`);
    logger.error(error.message);
    process.exit(1);
  }
}

/**
 * 创建新的 feature 分支
 */
async function startFeature(featureName) {
  await startBranch('feat', featureName);
}

/**
 * 创建新的 fix 分支
 */
async function startFix(fixName) {
  await startBranch('fix', fixName);
}

/**
 * 完成 feature（调用 squash-merge）
 */
async function finishFeature(branch) {
  const scriptPath = path.join(config.rootDir, '.scripts/git/squash-merge.js');

  try {
    await execNodeScript(scriptPath, [branch]);
  } catch (error) {
    logger.error(`没能结束 ${branch} 分支`);
    logger.error(error.message);
    process.exit(1);
  }
}

/**
 * 同步当前分支与 main
 */
async function syncWithMain() {
  const current = GitUtils.getCurrentBranch();

  if (current === 'main') {
    logger.warning('已经在 main 分支, 直接拉取最新代码...');
    logger.spinnerStart('拉取最新代码...');
    GitUtils.pull('origin', 'main');
    logger.spinnerSucceed('拉取最新代码完成');
    return;
  }

  logger.spinnerStart('拉取 main 并同步当前分支');
  await logger.spinnerShamefullySleep();

  try {
    // 更新 main
    logger.spinnerUpdate('拉取最新 main 分支...');
    GitUtils.checkout('main');
    GitUtils.pull('origin', 'main');
    await logger.spinnerShamefullySleep();

    // 切回原分支
    logger.spinnerUpdate(`返回 ${current} 分支...`);
    GitUtils.checkout(current);
    await logger.spinnerShamefullySleep();

    // Rebase
    logger.spinnerUpdate('在当前分支上，对 main 分支进行 rebase...');
    const rebaseResult = exec('git rebase main', { ignoreError: true, silent: true });
    await logger.spinnerShamefullySleep();

    if (rebaseResult === null) {
      // 可能有错误或冲突，检查 Git 状态
      const status = exec('git status', { silent: true });
      await logger.spinnerShamefullySleep();
      if (status && status.includes('rebase in progress')) {
        logger.spinnerWarn('Rebase 检测到冲突');
        logger.blank();
        logger.warning('请手动解决冲突:');
        logger.info('  解决后: git rebase --continue');
        logger.info('  取消: git rebase --abort');
      } else if (status && status.includes('Changes to be committed')) {
        logger.spinnerWarn('有没有提交的文件？请检查。');
      } else if (status && status.includes('Changes not staged for commit')) {
        logger.spinnerWarn('有未提交的文件？请检查。');
      } else {
        logger.spinnerFail('Rebase 失败');
      }
    } else if (rebaseResult.includes('up to date')) {
      logger.spinnerSucceed('分支已是最新');
    } else {
      logger.spinnerSucceed('在 main 分支上成功 rebase');
    }
  } catch (error) {
    logger.spinnerFail('同步失败');
    logger.error(error.message);
    process.exit(1);
  }
}

/**
 * 显示工作流状态
 */
function showStatus() {
  logger.title('Git Workflow Status');

  // 当前分支
  const current = GitUtils.getCurrentBranch();
  logger.info(`当前分支: <${current}>`);
  logger.blank();

  // Feature 分支
  const features = GitUtils.getBranches('feat/*');
  logger.info('Feature 分支:');
  if (features.length > 0) {
    logger.list(features);
  } else {
    logger.list(['(none)']);
  }
  logger.blank();

  // Fix 分支
  const fixes = GitUtils.getBranches('fix/*');
  if (fixes.length > 0) {
    logger.info('Fix 分支:');
    logger.list(fixes);
    logger.blank();
  }

  // Archive 分支
  const archives = GitUtils.getBranches('archive/*');
  logger.info(`Archive 分支: ${archives.length}`);
  if (archives.length > 0 && archives.length <= 10) {
    logger.list(archives);
  } else if (archives.length > 10) {
    logger.list([...archives.slice(0, 5), `... 和 ${archives.length - 5} 更多`]);
  }
}

// CLI 命令配置
program.name('git-workflow').description('Git workflow automation tool').version('1.0.0');

program
  .command('feat <feature-name>')
  .description('Start a new feature branch')
  .action(startFeature);

program.command('fix <fix-name>').description('Start a new fix branch').action(startFix);

program
  .command('finish <branch>')
  .description('Finish feature with squash merge')
  .action(finishFeature);

program.command('sync').description('Sync current branch with main').action(syncWithMain);

program.command('status').description('Show workflow status').action(showStatus);

// 解析命令行参数
program.parse();

// 没有命令时显示帮助
if (!process.argv.slice(2).length) {
  program.outputHelp();
}
